import dayjs from 'dayjs'
import type { TableColumnCtx } from 'element-plus'
import isBetween from 'dayjs/plugin/isBetween'
import weekOfYear from 'dayjs/plugin/weekOfYear'
dayjs.extend(isBetween)
dayjs.extend(weekOfYear)

const DATE_TIME_FORMAT = 'YYYY-MM-DD HH:mm:ss'
const DATE_FORMAT = 'YYYY-MM-DD'

const { t } = useI18n() // 国际化

export function formatToDateTime(date?: dayjs.ConfigType, format = DATE_TIME_FORMAT): string {
  return dayjs(date).format(format)
}

export function formatToDate(date?: dayjs.ConfigType, format = DATE_FORMAT): string {
  return dayjs(date).format(format)
}

export const dateUtil = dayjs

/**
 * 日期快捷选项适用于 el-date-picker
 */
export const defaultShortcuts = [
  {
    text: t('date', 'today'),
    value: () => {
      return new Date()
    }
  },
  {
    text: t('date', 'yesterday'),
    value: () => {
      const date = new Date()
      date.setTime(date.getTime() - 3600 * 1000 * 24)
      return [date, date]
    }
  },
  {
    text: t('date', 'lastDay7'),
    value: () => {
      const date = new Date()
      date.setTime(date.getTime() - 3600 * 1000 * 24 * 7)
      return [date, new Date()]
    }
  },
  {
    text: t('date', 'lastDay30'),
    value: () => {
      const date = new Date()
      date.setTime(date.getTime() - 3600 * 1000 * 24 * 30)
      return [date, new Date()]
    }
  },
  {
    text: t('date', 'thisMonth'),
    value: () => {
      const date = new Date()
      date.setDate(1) // 设置为当前月的第一天
      return [date, new Date()]
    }
  },
  {
    text: t('date', 'thisYear'),
    value: () => {
      const date = new Date()
      return [new Date(`${date.getFullYear()}-01-01`), date]
    }
  }
]

/**
 * Parse the time to string
 * @param {(Object|string|number)} time
 * @param {string} cFormat
 * @returns {string | null}
 */
export function parseTime(time, cFormat) {
  if (arguments.length === 0 || !time) {
    return null
  }
  const format = cFormat || '{y}-{m}-{d} {h}:{i}:{s}'
  let date
  if (typeof time === 'object') {
    date = time
  } else {
    if (typeof time === 'string') {
      if (/^[0-9]+$/.test(time)) {
        // support "1548221490638"
        time = parseInt(time)
      } else {
        // support safari
        // https://stackoverflow.com/questions/4310953/invalid-date-in-safari
        time = time.replace(new RegExp(/-/gm), '/')
      }
    }

    if (typeof time === 'number' && time.toString().length === 10) {
      time = time * 1000
    }
    date = new Date(time)
  }
  const formatObj = {
    y: date.getFullYear(),
    m: date.getMonth() + 1,
    d: date.getDate(),
    h: date.getHours(),
    i: date.getMinutes(),
    s: date.getSeconds(),
    a: date.getDay()
  }
  const time_str = format.replace(/{([ymdhisa])+}/g, (_result, key) => {
    const value = formatObj[key]
    // Note: getDay() returns 0 on Sunday
    if (key === 'a') {
      return [t('date', 'sun'), t('date', 'mon'), t('date', 'tue'), t('date', 'wed'), t('date', 'thu'), t('date', 'fri'), t('date', 'sat')][value]
    }
    return value.toString().padStart(2, '0')
  })
  return time_str
}

/**
 * @param {string} date YYYY-MM-DD | YYYY-MM-DD HH:mm:ss
 * @returns {string}
 */
export function formatTime(date) {
  const mistiming = Math.round((Date.now() - new Date(date).getTime()) / 1000)
  const tags = [t('date', 'year'), t('date', 'numMonth'), t('date', 'week'), t('date', 'numDay'), t('date', 'hours'), t('date', 'minutes'), t('date', 'second')]
  const times = [31536000, 2592000, 604800, 86400, 3600, 60, 1]
  for (let i = 0; i < times.length; i++) {
    const inm = Math.floor(mistiming / times[i])
    if (tags[i] === t('date', 'numDay')) {
      switch (inm) {
        case 0:
          return t('date', 'today')
        case 1:
          return t('date', 'yesterday')
        case 2:
          return t('date', 'lastDay2')
        default:
          return t('date', 'before', [inm, tags[i]])
      }
    }
    if (inm !== 0) {
      return t('date', 'before', [inm, tags[i]])
    }
  }
}

/**
 * 时间日期转换
 * @param date 当前时间，new Date() 格式
 * @param format 需要转换的时间格式字符串
 * @description format 字符串随意，如 `YYYY-mm、YYYY-mm-dd`
 * @description format 季度："YYYY-mm-dd HH:MM:SS QQQQ"
 * @description format 星期："YYYY-mm-dd HH:MM:SS WWW"
 * @description format 几周："YYYY-mm-dd HH:MM:SS ZZZ"
 * @description format 季度 + 星期 + 几周："YYYY-mm-dd HH:MM:SS WWW QQQQ ZZZ"
 * @returns 返回拼接后的时间字符串
 */
export function formatDate(date: Date, format?: string): string {
  // 日期不存在，则返回空
  if (!date) {
    return ''
  }
  // 日期存在，则进行格式化
  return date ? dayjs(date).format(format ?? 'YYYY-MM-DD HH:mm:ss') : ''
}

/**
 * 获取当前日期是第几周
 * @param dateTime 当前传入的日期值
 * @returns 返回第几周数字值
 */
export function getWeek(dateTime: Date): number {
  const temptTime = new Date(dateTime.getTime())
  // 周几
  const weekday = temptTime.getDay() || 7
  // 周1+5天=周六
  temptTime.setDate(temptTime.getDate() - weekday + 1 + 5)
  let firstDay = new Date(temptTime.getFullYear(), 0, 1)
  const dayOfWeek = firstDay.getDay()
  let spendDay = 1
  if (dayOfWeek != 0) spendDay = 7 - dayOfWeek + 1
  firstDay = new Date(temptTime.getFullYear(), 0, 1 + spendDay)
  const d = Math.ceil((temptTime.valueOf() - firstDay.valueOf()) / 86400000)
  return Math.ceil(d / 7)
}

/**
 * 将时间转换为 `几秒前`、`几分钟前`、`几小时前`、`几天前`
 * @param param 当前时间，new Date() 格式或者字符串时间格式
 * @param format 需要转换的时间格式字符串
 * @description param 10秒：  10 * 1000
 * @description param 1分：   60 * 1000
 * @description param 1小时： 60 * 60 * 1000
 * @description param 24小时：60 * 60 * 24 * 1000
 * @description param 3天：   60 * 60* 24 * 1000 * 3
 * @returns 返回拼接后的时间字符串
 */
export function formatPast(param: string | Date, format = 'YYYY-mm-dd HH:MM:SS'): string {
  const { t } = useI18n() // 国际化
  // 传入格式处理、存储转换值
  let a: any, s: number
  // 获取js 时间戳
  let time: number = new Date().getTime()
  // 是否是对象
  typeof param === 'string' || 'object' ? (a = new Date(param).getTime()) : (a = param)
  // 当前时间戳 - 传入时间戳
  time = Number.parseInt(`${time - a}`)
  if (time < 10000) {
    // 10秒内
    return t('date', 'just')
  } else if (time < 60000 && time >= 10000) {
    // 超过10秒少于1分钟内
    s = Math.floor(time / 1000)
    return t('date', 'beforeSecond', [s])
  } else if (time < 3600000 && time >= 60000) {
    // 超过1分钟少于1小时
    s = Math.floor(time / 60000)
    return t('date', 'beforeMinute', [s])
  } else if (time < 86400000 && time >= 3600000) {
    // 超过1小时少于24小时
    s = Math.floor(time / 3600000)
    return t('date', 'beforeHour', [s])
  } else if (time < 259200000 && time >= 86400000) {
    // 超过1天少于3天内
    s = Math.floor(time / 86400000)
    return t('date', 'beforeDay', [s])
  } else {
    // 超过3天
    const date = typeof param === 'string' || 'object' ? new Date(param) : param
    return formatDate(date, format)
  }
}

/**
 * 时间问候语
 * @param param 当前时间，new Date() 格式
 * @description param 调用 `formatAxis(new Date())` 输出 `上午好`
 * @returns 返回拼接后的时间字符串
 */
export function formatAxis(param: Date = new Date()): string {
  const { t } = useI18n() // 国际化
  const hour: number = new Date(param).getHours()
  if (hour < 6) return t('date', 'beforeDawn')
  else if (hour < 9) return t('date', 'morning')
  else if (hour < 12) return t('date', 'am')
  else if (hour < 14) return t('date', 'noon')
  else if (hour < 17) return t('date', 'afternoon')
  else if (hour < 19) return t('date', 'sunset')
  else if (hour < 22) return t('date', 'evening')
  else return t('date', 'night')
}

/**
 * 将毫秒，转换成时间字符串。例如说，xx 分钟
 *
 * @param ms 毫秒
 * @returns {string} 字符串
 */
export function formatPast2(ms: number): string {
  const { t } = useI18n() // 国际化
  const day = Math.floor(ms / (24 * 60 * 60 * 1000))
  const hour = Math.floor(ms / (60 * 60 * 1000) - day * 24)
  const minute = Math.floor(ms / (60 * 1000) - day * 24 * 60 - hour * 60)
  const second = Math.floor(ms / 1000 - day * 24 * 60 * 60 - hour * 60 * 60 - minute * 60)
  if (day > 0) {
    return t('date', 'countDownDDmm', [day, hour, minute])
  }
  if (hour > 0) {
    return t('date', 'countDownhhmm', [hour, minute])
  }
  if (minute > 0) {
    return t('date', 'countDownmm', [minute])
  }
  if (second > 0) {
    return t('date', 'countDownss', [second])
  } else {
    return t('date', 'countDownss', [0])
  }
}

/**
 * element plus 的时间 Formatter 实现，使用 YYYY-MM-DD HH:mm:ss 格式
 *
 * @param row 行数据
 * @param column 字段
 * @param cellValue 字段值
 */
export function dateTimeFormatter(_row: any, _column: TableColumnCtx<any>, cellValue: any): string {
  return cellValue ? formatDate(cellValue) : ''
}

/**
 * element plus 的时间 Formatter 实现，使用 YYYY-MM-DD 格式
 *
 * @param row 行数据
 * @param column 字段
 * @param cellValue 字段值
 */
export function dateFormatter(_row: any, _column: TableColumnCtx<any>, cellValue: any): string {
  return cellValue ? formatDate(cellValue, 'YYYY-MM-DD') : ''
}

/**
 * 设置起始日期，时间为00:00:00
 * @param param 传入日期
 * @returns 带时间00:00:00的日期
 */
export function beginOfDay(param: Date): Date {
  return new Date(param.getFullYear(), param.getMonth(), param.getDate(), 0, 0, 0)
}

/**
 * 设置结束日期，时间为23:59:59
 * @param param 传入日期
 * @returns 带时间23:59:59的日期
 */
export function endOfDay(param: Date): Date {
  return new Date(param.getFullYear(), param.getMonth(), param.getDate(), 23, 59, 59)
}

/**
 * 计算两个日期间隔天数
 * @param param1 日期1
 * @param param2 日期2
 */
export function betweenDay(param1: Date, param2: Date): number {
  param1 = convertDate(param1)
  param2 = convertDate(param2)
  // 计算差值
  return Math.floor((param2.getTime() - param1.getTime()) / (24 * 3600 * 1000))
}

/**
 * 日期计算
 * @param param1 日期
 * @param param2 添加的时间
 */
export function addTime(param1: Date, param2: number): Date {
  param1 = convertDate(param1)
  return new Date(param1.getTime() + param2)
}

/**
 * 日期转换
 * @param param 日期
 */
export function convertDate(param: Date | string): Date {
  if (typeof param === 'string') {
    return new Date(param)
  }
  return param
}

/**
 * 指定的两个日期, 是否为同一天
 * @param a 日期 A
 * @param b 日期 B
 */
export function isSameDay(a: dayjs.ConfigType, b: dayjs.ConfigType): boolean {
  if (!a || !b) return false

  const aa = dayjs(a)
  const bb = dayjs(b)
  return aa.year() == bb.year() && aa.month() == bb.month() && aa.day() == bb.day()
}

/**
 * 获取一天的开始时间、截止时间
 * @param date 日期
 * @param days 天数
 */
export function getDayRange(date: dayjs.ConfigType, days: number): [dayjs.ConfigType, dayjs.ConfigType] {
  const day = dayjs(date).add(days, 'd')
  return getDateRange(day, day)
}

/**
 * 获取最近7天的开始时间、截止时间
 */
export function getLast7Days(): [dayjs.ConfigType, dayjs.ConfigType] {
  const lastWeekDay = dayjs().subtract(7, 'd')
  const yesterday = dayjs().subtract(1, 'd')
  return getDateRange(lastWeekDay, yesterday)
}

/**
 * 获取最近30天的开始时间、截止时间
 */
export function getLast30Days(): [dayjs.ConfigType, dayjs.ConfigType] {
  const lastMonthDay = dayjs().subtract(30, 'd')
  const yesterday = dayjs().subtract(1, 'd')
  return getDateRange(lastMonthDay, yesterday)
}

/**
 * 获取最近1年的开始时间、截止时间
 */
export function getLast1Year(): [dayjs.ConfigType, dayjs.ConfigType] {
  const lastYearDay = dayjs().subtract(1, 'y')
  const yesterday = dayjs().subtract(1, 'd')
  return getDateRange(lastYearDay, yesterday)
}

/**
 * 获取指定日期的开始时间、截止时间
 * @param beginDate 开始日期
 * @param endDate 截止日期
 */
export function getDateRange(beginDate: dayjs.ConfigType, endDate: dayjs.ConfigType): [string, string] {
  return [dayjs(beginDate).startOf('d').format('YYYY-MM-DD HH:mm:ss'), dayjs(endDate).endOf('d').format('YYYY-MM-DD HH:mm:ss')]
}

/**
 * 日期格式：YYYY-MM-DD
 * @param start 开始日期
 * @param end 结束日期
 * @param other 需要判断的日期
 */
export const isDateInRange = (startDate, endDate, dateToCheck) => {
  // 将输入的日期转换为Day.js对象
  const start = dayjs(startDate)
  const end = dayjs(endDate)
  const check = dayjs(dateToCheck)

  // 判断日期是否在范围内
  return check.isBetween(start, end, 'day', '[]') // '[]'表示包括起始和结束日期
}

/**
 * 日期格式：YYYY-MM-DD HH:mm:ss
 * @param startDateTime 开始日期
 * @param endDateTime 结束日期
 * @param dateTimeToCheck 需要判断的日期
 */
export const isDateTimeInRange = (startDateTime, endDateTime, dateTimeToCheck) => {
  // 将输入的日期转换为Day.js对象
  const start = dayjs(startDateTime)
  const end = dayjs(endDateTime)
  const check = dayjs(dateTimeToCheck)

  // 判断日期是否在范围内
  return check.isBetween(start, end, undefined, '[]') // '[]'表示包括起始和结束日期
}

/**
 * 时间格式： YYYY-MM-DD HH:mm:ss
 * @param specifiedTime 比较时间
 * @param comparisonTime 被比较时间
 * @returns boolean
 */
export const isLessDateTime = (specifiedTime, comparisonTime) => {
  return dayjs(specifiedTime) < dayjs(comparisonTime)
}

export function isNow(val: string) {
  const nowDateTime = dayjs().format('YYYY-MM-DD HH:mm:ss')
  return nowDateTime === val
}

/**
 * 获取当前的日期+时间
 */
export function getNowDateTime() {
  return dayjs().format('YYYY-MM-DD HH:mm:ss')
}
/**
 * 获取当前的日期
 */
export function getNowDate() {
  return dayjs().format('YYYY-MM-DD')
}

/**
 * 根据指定的开始结束日期，获取范围内的一个随机时间
 * @param startDate 开始日期 YYYY-MM-DD
 * @param endDate 结束日期 YYYY-MM-DD
 * @returns 返回一个随机时间 YYYY-MM-DD HH:mm:ss
 */
export function getRandomDateTime(startDate, endDate) {
  const start = dayjs(startDate) // 设置随机时间的起始日期
  const end = dayjs(endDate) // 设置随机时间的结束日期
  const duration = end.diff(start) // 计算起始日期和结束日期之间的毫秒数
  const randomDate = start.add(Math.random() * duration) // 生成随机日期
  const randomTime = dayjs(randomDate).format('HH:mm:ss') // 生成随机时间并格式化
  return randomDate.format('YYYY-MM-DD ') + randomTime // 返回随机日期和时间的字符串表示
}

/**
 * 获取距离几天多少天的日期
 */
export function getCountDateTime(count: number) {
  if (count > 0) {
    return dayjs().add(1, 'day').format('YYYY-MM-DD HH:mm:ss')
  } else if (count < 0) {
    return dayjs().subtract(1, 'day').format('YYYY-MM-DD HH:mm:ss')
  } else {
    return dayjs().format('YYYY-MM-DD HH:mm:ss')
  }
}

// 将秒数转化为时分秒结构
export const durationToTime = (totalDuration, targetDuration) => {
  const pad = num => num.toString().padStart(2, '0')
  let hours, minutes, seconds
  if (totalDuration < 3600) {
    // 分秒结构 MM:SS
    minutes = Math.floor(targetDuration / 60)
    seconds = targetDuration % 60
    return `${pad(minutes)}:${pad(seconds)}`
  } else {
    // 时分秒结构 HH:MM:SS
    hours = Math.floor(targetDuration / 3600)
    const remaining = targetDuration % 3600
    minutes = Math.floor(remaining / 60)
    seconds = remaining % 60
    return `${pad(hours)}:${pad(minutes)}:${pad(seconds)}`
  }
}

// 将时分秒结构转化为秒数
export const timeToDuration = timeStr => {
  // 格式验证正则表达式（支持HH:MM:SS和MM:SS两种格式）
  const timeFormat = /^(?:(\d+):)?([0-5]?\d):([0-5]\d)$/
  // 执行正则匹配
  const match = timeStr.match(timeFormat)
  if (!match) {
    throw new Error('Invalid time format. Use HH:MM:SS or MM:SS')
  }

  // 提取时间组件（兼容两种格式）
  const hours = match[1] ? parseInt(match[1], 10) : 0
  const minutes = parseInt(match[2], 10)
  const seconds = parseInt(match[3], 10)

  // 计算总秒数
  return hours * 3600 + minutes * 60 + seconds
}

// 获取时间戳
export const getTimestamp = (date?: string) => {
  if (date) {
    return dayjs(date).toDate().getTime()
  } else {
    return dayjs().toDate().getTime()
  }
}

/**
 * 将时间戳转化为具体日期
 */
export function getDateByTimestamp(timestamp: number) {
  return dayjs(timestamp).format('YYYY-MM-DD')
}

export const getDatetimeByTimestamp = (timestamp: number) => {
  return dayjs(timestamp).format('YYYY-MM-DD HH:mm')
}

// 获取当前日期所在周的日期列表
export const getCurrentWeekList = () => {
  const weekStart = dayjs().startOf('week')
  const weekEnd = dayjs().endOf('week')
  const currentWeekDates: any = []

  for (let i = weekStart; i.isBefore(weekEnd); i = i.add(1, 'day')) {
    currentWeekDates.push({
      date: i.format('YYYY-MM-DD'),
      day: i.format('YYYY-MM-DD').split('-')[2]
    })
  }
  return currentWeekDates
}

/**
 * 获取未来 N 年后的今天的日期
 */
export function getFeatureDate(n: number) {
  return dayjs()
    .year(dayjs().year() + n)
    .format('YYYY-MM-DD')
}

/**
 * 获取未来 N 年后的今天的日期
 */
export function getDateMonth(n: number) {
  if (n < 0) {
    return dayjs().subtract(Math.abs(n), 'month').format('YYYY-MM-DD')
  } else {
    return dayjs().add(n, 'month').format('YYYY-MM-DD')
  }
}

// 获取两个日期之间的天数
export const getDayCount = (startDate: string, endDate: string) => {
  const start = dayjs(startDate)
  const end = dayjs(endDate)
  return end.diff(start, 'day')
}

// 通过出生日期获取年龄
export const getAge = (birthday: string) => {
  const birthDate = dayjs(birthday)
  const today = dayjs()
  const age = today.diff(birthDate, 'year')
  return age
}

// 获取指定日期是本年度第几周
export const getWeekCount = (date: string) => {
  return dayjs(date).week()
}
